package com.ultrawise.survey.common.utils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * 字符串工具类
 * 
 * @author wangyinan
 * 
 */
public class StringUtils {

	/**
	 * 
	 * <p>
	 * <b>功能描述:按分隔符切割元素，返回一个数组</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param sStr
	 * @param separator
	 * @return
	 */
	public static List Split(String sStr, String separator) {
		List list = new ArrayList();
		String newStr = sStr + separator;
		for (int i = 0; newStr != null && i < newStr.length();) {
			list.add(newStr.substring(i, newStr.indexOf(separator, i)));
			i = newStr.indexOf(separator, i) + separator.length();
		}
		return list;
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:按分隔符将数组元素分开，组成一个字符串</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param list
	 * @param separator
	 * @return
	 */
	public static String Join(List list, String separator) {
		String newString = "";
		for (int i = 0; list != null && i < list.size(); i++) {
			if (i != list.size() - 1) {
				newString = newString + (String) list.get(i) + separator;
			} else {
				newString = newString + (String) list.get(i);
			}
		}
		return newString;
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:全并相同项</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param sStr1
	 * @param sStr2
	 * @param separator
	 * @return
	 */
	public static String getUnion(String sStr1, String sStr2, String separator) {
		List list1 = Split(sStr1, separator);
		List list2 = Split(sStr2, separator);
		String newString = null;
		for (int i = 0; list2 != null && i < list2.size(); i++) {
			int nStatus = 0;
			for (int j = 0; list1 != null && j < list1.size(); j++) {
				if (((String) list2.get(i)).equalsIgnoreCase((String) list1
						.get(j))) {
					nStatus = 1;
				}
			}
			if (nStatus == 0) {
				list1.add((String) list2.get(i));
			}
		}
		newString = Join(list1, separator);
		return newString;
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:移除相同的项</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param sStr1
	 * @param sStr2
	 * @param separator
	 * @return
	 */
	public static String getSubtract(String sStr1, String sStr2,
			String separator) {
		List list1 = Split(sStr1, separator);
		List list2 = Split(sStr2, separator);
		String newString = null;

		for (int i = 0; list1 != null && i < list1.size(); i++) {
			for (int j = 0; list2 != null && j < list2.size(); j++) {
				if (((String) list1.get(i)).equalsIgnoreCase((String) list2
						.get(j))) {
					list1.remove(i);
				}
			}
		}
		newString = Join(list1, separator);
		return newString;
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:按分隔符将数组元素分开，组成一个字符串</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param list
	 * @param separator
	 * @return
	 */
	public static String Join(String[] list, String separator) {
		String newString = "";
		for (int i = 0; list != null && i < list.length; i++) {
			if (i != list.length - 1) {
				newString = newString + list[i] + separator;
			} else {
				newString = newString + list[i];
			}
		}
		return newString;
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:按分隔符将数组元素分开，组成一个字符串,每一项用单引号括起来</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param list
	 * @param separator
	 * @return
	 */
	public static String Join2SQL(String[] list, String separator) {
		String newString = "";
		for (int i = 0; list != null && i < list.length; i++) {
			if (i != list.length - 1) {
				newString = newString + "'" + list[i] + "'" + separator;
			} else {
				newString = newString + "'" + list[i] + "'";
			}
		}
		return newString;
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:按分隔符将数组元素分开，组成一个字符串,每一项用单引号括起来</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param list
	 * @param separator
	 * @return
	 */
	public static String Join2SQL(String str, String separator) {
		String[] list = str.split(separator);

		return Join2SQL(list, separator);
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述 :将字符串数组转换成List</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param array
	 * @return
	 */
	public static List converArrayToList(String[] array) {
		List list = new ArrayList();
		if (array != null && array.length != 0) {
			for (int i = 0; i < array.length; i++) {
				list.add(array[i]);
			}
		}
		return list;
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:获取文件的后缀名</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param filename
	 * @return
	 */
	public static String getFilePostfix(String filename) {
		return filename.substring(filename.lastIndexOf("."));
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:获取文件名，不带扩展名</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param filename
	 * @return
	 */
	public static String getFileBaseName(String filename) {
		return filename.substring(0, filename.lastIndexOf("."));
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述: 是否以 开头</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param filename
	 * @param filenames
	 * @return
	 */
	public static boolean isStartWith(String filename, String filenames) {
		String[] names = filenames.split(",");
		for (int i = 0; i < names.length; i++) {
			if (filename.startsWith(names[i]))
				return true;
		}
		return false;
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:转换路径，将\转换成/</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param pPath
	 * @return
	 */
	public static String converPath(String pPath) {
		String newstr = pPath;
		newstr = newstr.replace('\\', '/');
		return newstr;
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:得到文件名</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param pPath
	 * @return
	 */
	public static String getFilename(String pPath) {
		String newstr = pPath.substring(pPath.lastIndexOf("/") + 1,
				pPath.length());
		return newstr;
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:字符串按字节截取</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param str
	 * @param len
	 * @param elide
	 * @return
	 */
	public static String getMaxlengthSubString(String str, int len, String elide) {

		if (str == null) {
			return "";
		}
		byte[] strByte = str.getBytes();
		int strLen = strByte.length;
		int elideLen = (elide.trim().length() == 0) ? 0
				: elide.getBytes().length;

		if (len >= strLen || len < 1) {
			return str;
		}
		if (len - elideLen > 0) {
			len = len - elideLen;
		}
		int count = 0;
		for (int i = 0; i < len; i++) {
			int value = (int) strByte[i];
			if (value < 0) {
				count++;
			}
		}
		if (count % 2 != 0) {
			len = (len == 1) ? len + 1 : len - 1;
		}
		return new String(strByte, 0, len) + elide.trim();
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:按双字节计算截取maxlength长度的字符串</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param str
	 * @param maxlength
	 * @return
	 */
	public static String[] getLeftStringByChineseCode(String str, int maxlength) {
		int length = maxlength;
		int charCount = 0;
		String[] retrunValue = new String[2];

		if (str == null || str.equalsIgnoreCase(""))
			return null;
		if (str.length() <= maxlength) {
			retrunValue[0] = str;
			retrunValue[1] = null;
			return retrunValue;
		}

		for (int i = 0; i < str.substring(0, maxlength).length(); i++) {
			if (str.charAt(i) < 256) {
				charCount++;
			}
		}

		if (charCount % 2 == 0) {
			length = length + charCount / 2;
		} else {
			length = length + charCount / 2 + 1;
		}

		if (length - 1 < str.length() && charCount > 0
				&& str.charAt(length - 1) > 255) {
			// 如果最后一个字符为双字节
			length = length - 1;
		}
		retrunValue[0] = str.substring(0, (length > str.length() ? str.length()
				: length));

		if (length >= str.length()) {
			retrunValue[1] = null;
		} else {
			retrunValue[1] = str.substring(length);
		}
		return retrunValue;

	}

	/**
	 * 
	 * <p>
	 * <b>功能描述</b>
	 * 
	 * 按双字节计算,将一个字符串按size个字符分成多个字符串，并放入List返回, 分条说明: 一个条短信最多输入size个汉字 条数： N =3
	 * 一次最多可分三条 size*N个汉字 提示语: 首条提示 : 短信内容前+"共N条" 3个汉字 短信内容尾+"(待续)" 3个汉字
	 * 
	 * 中间的短信内容: 前 +“（接上）” 3个汉字 尾加 +“(待续)” 3个汉字
	 * 
	 * 最末条： 内容前 +“（接上）” 3个汉字 尾加 +“(-终-)” 3个汉字
	 * 
	 * 所以： 用户短信实际输入的汉字字数=size*N-N*3
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param content
	 * @param size
	 * @param clewinof
	 * @return
	 */
	public static List paginationBySmsContent(String content, int size,
			String clewinof) {
		List list = new ArrayList();
		String str = content;

		while (str != null && !str.equalsIgnoreCase("")) {

			if (str.length() <= size) {
				list.add(str + clewinof);
				str = null;
				break;
			} else {
				list.add(getLeftStringByChineseCode(str, size)[0]);
				if (getLeftStringByChineseCode(str, size)[1] != null
						&& !getLeftStringByChineseCode(str, size)[1]
								.equalsIgnoreCase("")) {
					str = getLeftStringByChineseCode(str, size)[1];
				} else {
					str = null;
				}
			}
		}

		// 超过一条,加提示语
		System.out.println("size:" + list.size());
		if (list.size() > 1) {
			for (int i = 0; i < list.size(); i++) {
				// 首条
				if (i == 0)
					list.set(i,
							"(共" + list.size() + "条)" + (String) list.get(i)
									+ "(待续)" + clewinof);

				// 中间条
				if (i > 0 && i != list.size() - 1)
					list.set(i, "(接上)" + (String) list.get(i) + "(待续)"
							+ clewinof);

				// 尾条
				if (i == list.size() - 1)
					list.set(i, "(接上)" + (String) list.get(i) + "(-终-)"
							+ clewinof);
			}
		}
		return list;
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:得到width长度的随机数字组成的字符串</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param width
	 * @return
	 */
	public static String getRand(int width) {
		Random random = new Random();
		String strRand = "";
		for (int i = 0; i < width; i++) {
			String rand = String.valueOf(random.nextInt(10));
			strRand += rand;
		}
		return strRand;
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:在右边补足width位</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param str
	 * @param width
	 * @param inip
	 * @return
	 */
	public static String varchar2charRight(String str, int width, String inip) {
		String newstr = str;
		for (int i = str.length(); i < width; i++) {
			newstr = newstr + inip;
		}
		return newstr;

	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:在左边补足width位</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param str
	 * @param width
	 * @param inip
	 * @return
	 */
	public static String varchar2charLeft(String str, int width, String inip) {
		String newstr = "";
		for (int i = str.length(); i < width; i++) {
			newstr = newstr + inip;
		}
		newstr += str;
		return newstr;

	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:将 s 进行 BASE64 编码</b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param s
	 * @return
	 */
	public static String encodeBase64(byte[] s) {
		if (s == null)
			return null;
		return (new BASE64Encoder()).encode(s);
	}

	/**
	 * 
	 * <p>
	 * <b>功能描述:将 BASE64 编码的字符串 s 进行解码 </b>
	 * <ul>
	 * <li>可见性原因：需要被其他应用调用</li>
	 * <li>目的：检查签名</li>
	 * <li>适用的前提条件:</li>
	 * <li>后置条件：</li>
	 * <li>例外处理：无</li>
	 * <li>已知问题：</li>
	 * <li>调用的例子：</li>
	 * </ul>
	 * </p>
	 * 
	 * @param s
	 * @return
	 */
	public static String encodeHex(String s) {
		if (s == null)
			return null;
		BASE64Decoder decoder = new BASE64Decoder();
		try {
			byte[] b = decoder.decodeBuffer(s);
			return new String(b);
		} catch (Exception e) {
			return null;
		}

	}

	/**
	 * 获取问号前的地址串
	 * 
	 * @param urlStr
	 * @return
	 */
	public static String getURI(String urlStr, String appPath) {
		String url = "";

		int i = urlStr.indexOf("//");
		i = urlStr.indexOf("/", i + 2);

		if (i == -1) {
			return "";
		} else {
			i = i + 1;
		}
		int j = urlStr.indexOf("?");
		if (j != -1) {
			url = urlStr.substring(i, j);
		} else {
			url = urlStr.substring(i);
		}
		return url;
	}

	/**
	 * 获取页面的带的参数串
	 * 
	 * @param urlStr
	 * @return
	 */
	public static String getParameter(String urlStr) {
		String parameter = "";
		int i = urlStr.indexOf('?');
		if (i != -1)
			parameter = urlStr.substring(i + 1);
		return parameter;
	}

	/**
	 * 获取访问页面所在的目录
	 * 
	 * @param urlStr
	 * @return
	 */
	public static String getDIR(String urlStr) {
		String dir = null;
		int i = urlStr.indexOf("//");
		if (i == -1)
			return "";
		i = urlStr.indexOf("/", i + 2);
		if (i == -1)
			return "";
		int j = urlStr.lastIndexOf("/");
		if (j == -1)
			return "";
		dir = urlStr.substring(i, j + 1);
		return dir;
	}

	/**
	 * 获取访问页面所使用的域名
	 * 
	 * @param urlStr
	 * @return
	 */
	public static String getDomain(String urlStr) {
		String domain = null;
		int i = urlStr.indexOf("//");
		if (i == -1)
			return "";
		int j = urlStr.indexOf("/", i + 2);
		if (j == -1) {
			domain = urlStr.substring(i + 2);
		} else {
			domain = urlStr.substring(i + 2, j);
		}
		return domain;
	}

	public static List regexpString(String input, String regexp) {
		List returnStr = new ArrayList<String>();
		String regexpStr = "\\$\\{[^${}]*\\}";
		if (regexp != null && regexp.length() > 0)
			regexpStr = regexp;
		Pattern pattern = Pattern.compile(regexpStr);

		if (input != null && input.length() > 0) {
			Matcher matcher = pattern.matcher(input);
			boolean find = matcher.find();
			while (find) {
				returnStr.add(matcher.group());
				find = matcher.find();
			}
		}
		return returnStr;
	}

	public static List regexpString(String input) {
		return regexpString(input, null);
	}

	/****
	 * 判断字符串是否是数字
	 * 
	 * @param str
	 * @return
	 */
	public static boolean isNumeric(String str) {
		if (str == null || (str != null && str.trim().length() <= 0))
			return false;

		for (int i = str.length(); --i >= 0;) {
			if (!Character.isDigit(str.charAt(i))) {
				return false;
			}
		}
		return true;

	}

	public static boolean isNum(String num) {
		if (num == null || !Pattern.matches("[0-9]*", num)) {
			return false;
		} else
			return true;
	}

	/****
	 * 把对象转化成字符串
	 * 
	 * @param obj
	 * @return
	 */
	public static String toStringByObject(Object obj) {
		String obstr = String.valueOf(obj);
		if (obstr == null || obstr.equalsIgnoreCase("null"))
			obstr = "";
		return obstr;
	}

	/*****
	 * 
	 * @param map
	 *            <String,String> keyjoin
	 * @param separator
	 * @return
	 */
	public static String join2ByMapkey(Map<String, String> map, String separator) {
		String newString = "";
		if (map != null && map.size() > 0) {
			int i = 0;
			for (Map.Entry<String, String> entry : map.entrySet()) {
				if (i != (map.size() - 1)) {
					newString = newString + "'" + entry.getKey() + "'"
							+ separator;
				} else {
					newString = newString + "'" + entry.getKey() + "'";
				}
				i++;
			}
		}
		return newString;
	}

	/*****
	 * 判断字符串为空字符串
	 * 
	 * @param str
	 * @return
	 */
	public static boolean isEmpty(String str) {
		if (str != null && str.length() > 0)
			return false;
		else
			return true;
	}

	public static boolean isNotEmpty(String str) {
		if (isEmpty(str))
			return false;
		else
			return true;
	}

	/***
	 * 返回ascii值信息
	 * 
	 * @param s
	 * @return
	 */
	public static int getAscii(String s) {
		int ascii = 0;
		for (int i = 0; i < s.length(); i++) {
			ascii += s.charAt(i);
			System.out.println(s.charAt(i));
		}
		return ascii;
	}
	
	public static void main(String[] args) {
		System.out.println(getStringIncludeNum("aaaaaa","aa"));
	}
	
	/****
	 * 获取字符串包含某字符串的个数
	 * @param str
	 * @param includestr
	 * @return
	 */
	public static int getStringIncludeNum(String str, String includestr) {
		int cnt = 0, start = 0;
		while (start <= str.length()) {
			int i = str.indexOf(includestr, start);
			if (i >= 0) {
				cnt++;
				start = i + includestr.length();
			} else
				break;
		}
		return cnt;
	}
}
